home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / emulator / bsvc-1.000 / bsvc-1 / bsvc-1.0.4 / src / SimHector / cpu / ControlUnit.cxx < prev    next >
C/C++ Source or Header  |  1995-07-26  |  8KB  |  270 lines
  1. ///////////////////////////////////////////////////////////////////////////////
  2. //
  3. // ControlUnit.cxx - Control Unit for the Hector 1600 CPU
  4. //                   (behavioral level)
  5. //
  6. // By: Bradford W. Mott
  7. // December 4,1993
  8. //
  9. ///////////////////////////////////////////////////////////////////////////////
  10.  
  11. #include "ControlUnit.hxx"
  12. #include "Tools.hxx"
  13.  
  14. ///////////////////////////////////////////////////////////////////////////////
  15. // Execute the next instruction
  16. ///////////////////////////////////////////////////////////////////////////////
  17. const char* ControlUnit::ExecuteInstruction(String& trace_record,
  18.                                             int trace_flag)
  19. {
  20.   const char *error_message;
  21.  
  22.   // Reset the Data Path Signals
  23.   data_path.ResetSignals();
  24.  
  25.   // Added the Instruction Address field to the trace_record if tracing
  26.   if(trace_flag)
  27.   {
  28.     trace_record+="{InstructionAddress {";
  29.     trace_record+=IntToString(data_path.register_set.GetRegister(PC), 4);
  30.     trace_record+="}}";
  31.   } 
  32.  
  33.   // Fetch the next instruction and put it in IR
  34.   data_path.a_sel(PC);
  35.   data_path.mar_sel(A_BUS);
  36.   data_path.mar_latch();
  37.   data_path.mar_out_en();
  38.   data_path.ir_latch();
  39.   data_path.alu_fn(INC_A_NCC);
  40.   data_path.alu_gt();
  41.   data_path.wrt_a();
  42.   if(( error_message = data_path.Clock() ) != (void*)0)
  43.     return(error_message);
  44.  
  45.   error_message=DecodeAndExecute(trace_flag);
  46.  
  47.   // If there wasn't an error then add the mnemonic to the trace_record
  48.   if((error_message == (void*)0) && trace_flag)
  49.   {
  50.     mnemonic+="}}";
  51.     trace_record+=" ";
  52.     trace_record+=mnemonic;
  53.   }
  54.  
  55.   return(error_message);
  56. }
  57.  
  58. ///////////////////////////////////////////////////////////////////////////////
  59. // Decode the instruction in the IR register and execute it
  60. ///////////////////////////////////////////////////////////////////////////////
  61. const char* ControlUnit::DecodeAndExecute(int trace_flag)
  62. {
  63.   const char* error_message;
  64.   int dm = (data_path.ir & 0x0300) >> 8;    // Destination Mode field
  65.   int sm = (data_path.ir & 0x0c00) >> 10;   // Source Mode field
  66.  
  67.  
  68.   // Setup the mnemonic trace entry
  69.   if(trace_flag)
  70.     mnemonic="{Mnemonic {";
  71.  
  72.   switch ((data_path.ir & 0xf000) >> 12)
  73.   {
  74.     case 0:    // ADD
  75.       if(trace_flag) mnemonic+="ADD ";
  76.       error_message=ExecuteGroup1(trace_flag);
  77.       break;
  78.  
  79.     case 1:    // ADDC
  80.       if(trace_flag) mnemonic+="ADDC ";
  81.       error_message=ExecuteGroup1(trace_flag);
  82.       break;
  83.  
  84.     case 2:    // SUB
  85.       if(trace_flag) mnemonic+="SUB ";
  86.       error_message=ExecuteGroup1(trace_flag);
  87.       break; 
  88.  
  89.     case 3:    // AND
  90.       if(trace_flag) mnemonic+="AND ";
  91.       error_message=ExecuteGroup1(trace_flag);
  92.       break;
  93.  
  94.     case 4:    // SUBC
  95.       if(trace_flag) mnemonic+="SUBC ";
  96.       error_message=ExecuteGroup1(trace_flag);
  97.       break; 
  98.  
  99.     case 5:    // OR
  100.       if(trace_flag) mnemonic+="OR ";
  101.       error_message=ExecuteGroup1(trace_flag);
  102.       break; 
  103.  
  104.     case 6:    // XOR
  105.       if(trace_flag) mnemonic+="XOR ";
  106.       error_message=ExecuteGroup1(trace_flag);
  107.       break; 
  108.  
  109.     case 7:    // Stop
  110.       error_message="STOP instruction";
  111.       break;
  112.  
  113.     case 8:    // NOT, NEG, INC, DEC
  114.       switch (dm)
  115.       {
  116.         case 0:    // NOT
  117.           if(trace_flag) mnemonic+="NOT ";
  118.           error_message=ExecuteGroup2(trace_flag);
  119.           break; 
  120.         case 1:    // NEG
  121.           if(trace_flag) mnemonic+="NEG ";
  122.           error_message=ExecuteGroup2(trace_flag);
  123.           break; 
  124.         case 2:    // INC
  125.           if(trace_flag) mnemonic+="INC ";
  126.           error_message=ExecuteGroup2(trace_flag);
  127.           break; 
  128.         case 3:    // DEC
  129.           if(trace_flag) mnemonic+="DEC ";
  130.           error_message=ExecuteGroup2(trace_flag);
  131.           break; 
  132.       }
  133.       break;
  134.  
  135.     case 9:    // SHL, ROL, SHR, ROR
  136.       switch (dm)
  137.       {
  138.         case 0:    // SHL
  139.           if(trace_flag) mnemonic+="SHL ";
  140.           error_message=ExecuteGroup2(trace_flag);
  141.           break; 
  142.         case 1:    // ROL
  143.           if(trace_flag) mnemonic+="ROL ";
  144.           error_message=ExecuteGroup2(trace_flag);
  145.           break; 
  146.         case 2:    // SHR
  147.           if(trace_flag) mnemonic+="SHR ";
  148.           error_message=ExecuteGroup2(trace_flag);
  149.           break; 
  150.         case 3:    // ROR
  151.           if(trace_flag) mnemonic+="ROR ";
  152.           error_message=ExecuteGroup2(trace_flag);
  153.           break; 
  154.       }
  155.       break;
  156.  
  157.     case 10:    // CMP
  158.       if(trace_flag) mnemonic+="CMP ";
  159.       error_message=ExecuteGroup3(trace_flag);
  160.       break; 
  161.  
  162.     case 11:    // BTST
  163.       if(trace_flag) mnemonic+="BTST ";
  164.       error_message=ExecuteGroup3(trace_flag);
  165.       break; 
  166.  
  167.     case 12:    // BRA, JSR, SWAP, CLR
  168.       switch (dm)
  169.       {
  170.         case 0:    // BRA
  171.           if(trace_flag) mnemonic+="BRA ";
  172.           error_message=ExecuteBRA(trace_flag);
  173.           break;
  174.         case 1:    // JSR
  175.           if(trace_flag) mnemonic+="JSR ";
  176.           error_message=ExecuteJSR(trace_flag);
  177.           break;
  178.         case 2:    // SWAP
  179.           if(trace_flag) mnemonic+="SWAP ";
  180.           error_message=ExecuteSWAP(trace_flag);
  181.           break;
  182.         case 3:    // CLR
  183.           if(trace_flag) mnemonic+="CLR ";
  184.           error_message=ExecuteCLR(trace_flag);
  185.           break;
  186.       }
  187.       break;
  188.  
  189.     case 13:    // MOVE
  190.       if(trace_flag) mnemonic+="MOVE ";
  191.       error_message=ExecuteMOVE(trace_flag);
  192.       break;
  193.  
  194.     case 14:    // TEST, STF, LDF, PUSH
  195.       switch (dm)
  196.       {
  197.         case 0:    // TEST
  198.           if(trace_flag) mnemonic+="TEST ";
  199.           error_message=ExecuteTEST(trace_flag);
  200.           break;
  201.         case 1:    // STF
  202.           if(trace_flag) mnemonic+="STF ";
  203.           error_message=ExecuteSTF(trace_flag);
  204.           break;
  205.         case 2:    // LDF
  206.           if(trace_flag) mnemonic+="LDF ";
  207.           error_message=ExecuteLDF(trace_flag);
  208.           break;
  209.         case 3:    // PUSH
  210.           if(trace_flag) mnemonic+="PUSH ";
  211.           error_message=ExecutePUSH(trace_flag);
  212.           break; 
  213.       }
  214.       break;
  215.  
  216.     case 15:    // SEC, CLC, SEI, CLI, RTI, SWI, EXCH, SRCH
  217.       switch (sm)
  218.       {
  219.         case 0:    // SEC, CLC, SEI, CLI
  220.           switch (dm)
  221.           { 
  222.             case 0:    // SEC
  223.               if(trace_flag) mnemonic+="SEC ";
  224.               error_message=ExecuteSEC(trace_flag);
  225.               break;
  226.             case 1:    // CLC
  227.               if(trace_flag) mnemonic+="CLC ";
  228.               error_message=ExecuteCLC(trace_flag);
  229.               break;
  230.             case 2:    // SEI
  231.               if(trace_flag) mnemonic+="SEI ";
  232.               error_message=ExecuteSEI(trace_flag);
  233.               break;
  234.             case 3:    // CLI
  235.               if(trace_flag) mnemonic+="CLI ";
  236.               error_message=ExecuteCLI(trace_flag);
  237.               break;
  238.           }
  239.           break;
  240.         case 1:    // RTI, SWI, EXCH, SRCH
  241.           switch (dm)
  242.           { 
  243.             case 0:    // RTI
  244.               if(trace_flag) mnemonic+="RTI ";
  245.               error_message=ExecuteRTI(trace_flag);
  246.               break;
  247.             case 1:    // SWI
  248.               if(trace_flag) mnemonic+="SWI ";
  249.               error_message=ExecuteSWI(trace_flag);
  250.               break;
  251.             case 2:    // EXCH
  252.               if(trace_flag) mnemonic+="EXCH ";
  253.               error_message=ExecuteEXCH(trace_flag);
  254.               break;
  255.             case 3:    // SRCH
  256.               if(trace_flag) mnemonic+="SRCH ";
  257.               error_message=ExecuteSRCH(trace_flag);
  258.               break;
  259.           }
  260.           break;
  261.       }
  262.       break;
  263.  
  264.     default:
  265.       error_message="Illegal Opcode";
  266.       break;
  267.   }
  268.   return(error_message);
  269. }
  270.